home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / windownt / uupc11yt.zip / TEST / TPROT.C < prev   
C/C++ Source or Header  |  1992-11-22  |  7KB  |  274 lines
  1. /* uucp 't' protocol */
  2.  
  3. #ifndef lint
  4. static char sccsid[] = "@(#)tio.c       4.9     (Berkeley) 5/4/88";
  5. #endif
  6.  
  7. #include <signal.h>
  8. #include "uucp.h"
  9. #include <setjmp.h>
  10. #include <sys/stat.h>
  11. #include <netinet/in.h>
  12.  
  13. extern int pkfail();
  14. #define TPACKSIZE       512
  15. #define TBUFSIZE        1024
  16. #define min(a,b)        (((a)<(b))?(a):(b))
  17.  
  18. /*
  19.  *      htonl is a function that converts a long from host
  20.  *              order to network order
  21.  *      ntohl is a function that converts a long from network
  22.  *              order to host order
  23.  *
  24.  *      network order is                0 1 2 3 (bytes in a long)
  25.  *      host order on a vax is          3 2 1 0
  26.  *      host order on a pdp11 is        1 0 3 2
  27.  *      host order on a 68000 is        0 1 2 3
  28.  *      most other machines are         0 1 2 3
  29.  */
  30.  
  31. struct tbuf {
  32.         long t_nbytes;
  33.         char t_data[TBUFSIZE];
  34. };
  35.  
  36. extern jmp_buf Failbuf;
  37.  
  38. extern long Bytes_Sent, Bytes_Received;
  39.  
  40. twrmsg(type, str, fn)
  41. char type;
  42. register char *str;
  43. {
  44.         char bufr[TBUFSIZE];
  45.         register char *s;
  46.         int len, i;
  47.  
  48.         if(setjmp(Failbuf))
  49.                 return FAIL;
  50.         signal(SIGALRM, pkfail);
  51.         alarm(MAXMSGTIME*5);
  52.         bufr[0] = type;
  53.         s = &bufr[1];
  54.         while (*str)
  55.                 *s++ = *str++;
  56.         *s = '\0';
  57.         if (*(--s) == '\n')
  58.                 *s = '\0';
  59.         len = strlen(bufr) + 1;
  60.         if ((i = len % TPACKSIZE)) {
  61.                 len = len + TPACKSIZE - i;
  62.                 bufr[len - 1] = '\0';
  63.         }
  64.         twrblk(bufr, len, fn);
  65.         alarm(0);
  66.         return SUCCESS;
  67. }
  68.  
  69. trdmsg(str, fn)
  70. register char *str;
  71. {
  72.         int len, cnt = 0;
  73.  
  74.         if(setjmp(Failbuf))
  75.                 return FAIL;
  76.         signal(SIGALRM, pkfail);
  77.         alarm(MAXMSGTIME*5);
  78.         for (;;) {
  79.                 len = read(fn, str, TPACKSIZE);
  80.                 if (len <= 0) {
  81.                         alarm(0);
  82.                         return FAIL;
  83.                 }
  84.                 str += len;
  85.                 cnt += len;
  86.                 if (*(str - 1) == '\0' && (cnt % TPACKSIZE) == 0)
  87.                         break;
  88.         }
  89.         alarm(0);
  90.         return SUCCESS;
  91. }
  92.  
  93. twrdata(fp1, fn)
  94. FILE *fp1;
  95. {
  96.         struct tbuf bufr;
  97.         register int len;
  98.         int ret, mil;
  99.         struct timeb t1, t2;
  100.         long bytes;
  101.         char text[TBUFSIZE];
  102.         float ft;
  103.  
  104.         if(setjmp(Failbuf))
  105.                 return FAIL;
  106.         signal(SIGALRM, pkfail);
  107.         bytes = 0L;
  108. #ifdef USG
  109.         time(&t1.time);
  110.         t1.millitm = 0;
  111. #else !USG
  112.         ftime(&t1);
  113. #endif !USG
  114.         while ((len = read(fileno(fp1), bufr.t_data, TBUFSIZE)) > 0) {
  115.                 bytes += len;
  116.                 bufr.t_nbytes = htonl((long)len);
  117.                 DEBUG(8,"twrdata sending %d bytes\n",len);
  118.                 len += sizeof(long);
  119.                 alarm(MAXMSGTIME*5);
  120.                 ret = twrblk((char *)&bufr, len, fn);
  121.                 alarm(0);
  122.                 if (ret != len)
  123.                         return FAIL;
  124.                 if (len != TBUFSIZE+sizeof(long))
  125.                         break;
  126.         }
  127.         if (len < 0) {
  128.                 alarm(0);
  129.                 return FAIL;
  130.         }
  131.         bufr.t_nbytes = 0;
  132.         len = sizeof(long);
  133.         alarm(MAXMSGTIME*5);
  134.         ret = twrblk((char *)&bufr, len, fn);
  135.         alarm(0);
  136.         if (ret != len)
  137.                 return FAIL;
  138. #ifdef USG
  139.         time(&t2.time);
  140.         t2.millitm = 0;
  141. #else !USG
  142.         ftime(&t2);
  143. #endif !USG
  144.         Now = t2;
  145.         t2.time -= t1.time;
  146.         mil = t2.millitm - t1.millitm;
  147.         if (mil < 0) {
  148.                 --t2.time;
  149.                 mil += 1000;
  150.         }
  151.         ft = (float)t2.time + (float)mil/1000.;
  152.         if (ft == 0.0)                  /* avoid /0.0 ... kre */
  153.                 ft = 1.0;
  154.         sprintf(text, "sent data %ld bytes %.2f secs %ld bps",
  155.                 bytes, ft, (long)((float)bytes*8./ft));
  156.         sysacct(bytes, t2.time);
  157.         Bytes_Sent += bytes;
  158.         DEBUG(1, "%s\n", text);
  159.         log_xferstats(text);
  160.         return SUCCESS;
  161. }
  162.  
  163. trddata(fn, fp2)
  164. FILE *fp2;
  165. {
  166.         register int len, nread;
  167.         char bufr[TBUFSIZE];
  168.         struct timeb t1, t2;
  169.         int mil;
  170.         long bytes, Nbytes;
  171.         float ft;
  172.  
  173.         if(setjmp(Failbuf))
  174.                 return FAIL;
  175.         signal(SIGALRM, pkfail);
  176. #ifdef USG
  177.         time(&t1.time);
  178.         t1.millitm = 0;
  179. #else !USG
  180.         ftime(&t1);
  181. #endif !USG
  182.         bytes = 0L;
  183.         for (;;) {
  184.                 alarm(MAXMSGTIME*5);
  185.                 len = trdblk((char *)&Nbytes,sizeof Nbytes,fn);
  186.                 alarm(0);
  187.                 if (len != sizeof Nbytes)
  188.                         return FAIL;
  189.                 Nbytes = ntohl(Nbytes);
  190.                 DEBUG(8,"trddata expecting %ld bytes\n",Nbytes);
  191.                 nread = Nbytes;
  192.                 if (nread == 0)
  193.                         break;
  194.                 alarm(MAXMSGTIME*5);
  195.                 len = trdblk(bufr, nread, fn);
  196.                 alarm(0);
  197.                 if (len < 0) {
  198.                         return FAIL;
  199.                 }
  200.                 bytes += len;
  201.                 DEBUG(11,"trddata got %ld\n",bytes);
  202.                 if (write(fileno(fp2), bufr, len) != len) {
  203.                         alarm(0);
  204.                         return FAIL;
  205.                 }
  206.         }
  207. #ifdef USG
  208.         time(&t2.time);
  209.         t2.millitm = 0;
  210. #else !USG
  211.         ftime(&t2);
  212. #endif !USG
  213.         Now = t2;
  214.         t2.time -= t1.time;
  215.         mil = t2.millitm - t1.millitm;
  216.         if (mil < 0) {
  217.                 --t2.time;
  218.                 mil += 1000;
  219.         }
  220.         ft = (float)t2.time + (float)mil/1000.;
  221.         if (ft == 0.0)
  222.                 ft = 1.0;
  223.         sprintf(bufr, "received data %ld bytes %.2f secs %ld bps",
  224.                 bytes, ft, (long)((float)bytes*8./ft));
  225.         sysacct(bytes, t2.time);
  226.         Bytes_Received += bytes;
  227.         DEBUG(1, "%s\n", bufr);
  228.         log_xferstats(bufr);
  229.         return SUCCESS;
  230. }
  231.  
  232. #if !defined(BSD4_2) && !defined(USG)
  233. #define TC      1024
  234. static  int tc = TC;
  235. #endif !BSD4_2 && !USG
  236.  
  237. trdblk(blk, len,  fn)
  238. register int len;
  239. char *blk;
  240. {
  241.         register int i, ret;
  242.  
  243. #if !defined(BSD4_2) && !defined(USG)
  244.         /* call ultouch occasionally */
  245.         if (--tc < 0) {
  246.                 tc = TC;
  247.                 ultouch();
  248.         }
  249. #endif !BSD4_2 && !USG
  250.         for (i = 0; i < len; i += ret) {
  251.                 ret = read(fn, blk, len - i);
  252.                 if (ret < 0)
  253.                         return FAIL;
  254.                 blk += ret;
  255.                 if (ret == 0)
  256.                         return i;
  257.         }
  258.         return i;
  259. }
  260.  
  261.  
  262. twrblk(blk, len, fn)
  263. register char *blk;
  264. {
  265. #if !defined(BSD4_2) && !defined(USG)
  266.         /* call ultouch occasionally */
  267.         if (--tc < 0) {
  268.                 tc = TC;
  269.                 ultouch();
  270.         }
  271. #endif !BSD4_2 && !USG
  272.         return write(fn, blk, len);
  273. }
  274.